/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package net.etrs.formathlon.vue.jsf.form.visitor;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.annotation.PostConstruct;
import javax.ejb.EJB;
import javax.faces.bean.ManagedBean;
import javax.faces.bean.ViewScoped;
import javax.faces.event.ActionEvent;
import net.etrs.formathlon.entity.formation.Seance;
import net.etrs.formathlon.entity.formation.Session;
import net.etrs.formathlon.entity.utilisateur.Personnel;
import net.etrs.formathlon.metier.exception.MetierException;
import net.etrs.formathlon.metier.service.EntiteManager.NiveauHierarchique;
import net.etrs.formathlon.metier.utils.constantes.RoleSpring;
import net.etrs.formathlon.persistance.formation.InscriptionFacade;
import net.etrs.formathlon.persistance.formation.SessionFacade;
import net.etrs.formathlon.persistance.utilisateur.PersonnelFacade;
import net.etrs.formathlon.vue.exception.VueException;
import net.etrs.formathlon.vue.jsf.utils.GeneralBean;
import org.primefaces.event.ScheduleEntrySelectEvent;
import org.primefaces.model.DefaultScheduleEvent;
import org.primefaces.model.DefaultScheduleModel;
import org.primefaces.model.ScheduleEvent;
import org.primefaces.model.ScheduleModel;

/**
 * ManageBean JSF pour les pages traitant de l'administration du planning de 
 * visualisation des sessions.
 * @author OPIF
 */
@ManagedBean
@ViewScoped
public class VisitorPlanningBean extends GeneralBean {

    /* Liste pour afficher les événements dans le calendrier */
    private ScheduleModel eventModel;
    /* Evénement */
    private ScheduleEvent event = new DefaultScheduleEvent();
    @EJB
    private InscriptionFacade inscriptionFacade;
    @EJB
    private PersonnelFacade personnelFacade;
    @EJB
    private SessionFacade sessionFacade;
    /* liste de toutes les sessions ouvertes */
    private List<Session> listSession = new ArrayList<Session>();
    /* liste des seances d une session */
    private List<Seance> listSeance = new ArrayList<Seance>();
    private Seance seance;
    private Personnel personnel;
    private Date initialDateSchedule;

    /** Creates a new instance of VisitorPlanningBean */
    public VisitorPlanningBean() {
    }

    /**
     * Methode d'initialisation.
     */
    @PostConstruct
    public void init() {
        eventModel = new DefaultScheduleModel();
        //recup toutes les sesions ouvertes
        listSession = sessionFacade.getSessionOuvertes();

        //nettoyage de la liste affichée dans le planning
        eventModel.clear();

        //remplissage de la liste a affiché dans le planning
        StringBuilder chaine = new StringBuilder();

        for (Session session : listSession) {
            //pour concaténer la chaine de caractere à afficher
            chaine.delete(0, chaine.length());
            listSeance = session.getListSeance();
            chaine.append(session.getFormation().getLibelle());

            for (Seance s : listSeance) {
                DefaultScheduleEvent eventTemp = new DefaultScheduleEvent(chaine.toString(), s.getDateHeureDebut(), s.getDateHeureFin(), false);
                eventTemp.setData(s);
                eventModel.addEvent(eventTemp);
            }
        }
    }

    /**
     * Action de s'inscrir.
     */
    public void inscrire() {

        try {
            inscriptionFacade.inscrire(personnel, seance.getSession(), getLoginControler().isChefCours());
            displayMessage(String.format("%s a été inscrit.", personnel));
        } catch (MetierException ex) {
            Logger.getLogger(VisitorSessionBean.class.getName()).log(Level.SEVERE, null, ex);
            displayAlert(ex.getMessage());
        }

    }

    /**
     * @return the eventModel
     */
    public ScheduleModel getEventModel() {
        return eventModel;
    }

    /**
     * Ajout d'un event dans le planning.
     * @param actionEvent 
     */
    public void addEvent(ActionEvent actionEvent) {
        if (getEvent().getId() == null) {
            eventModel.addEvent(getEvent());
        } else {
            eventModel.updateEvent(getEvent());
        }
        setEvent(new DefaultScheduleEvent());
    }

    /**
     * Action lancé lors de la sélection d'un event.
     * @param selectEvent 
     */
    public void onEventSelect(ScheduleEntrySelectEvent selectEvent) {
        setEvent(selectEvent.getScheduleEvent());
    }

    /**
     * @return the event
     */
    public ScheduleEvent getEvent() {
        return event;
    }

    /**
     * @param event the event to set
     */
    public void setEvent(ScheduleEvent event) {
        this.event = event;
        this.seance = (Seance) event.getData();
    }

    /**
     * @return la seance
     */
    public Seance getSeance() {
        return seance;
    }

    /**
     * Permet d'ouvrir un popup
     */
    public void creer() {
        setInitialDateSchedule(event.getStartDate());
        getPopupBean().open(getMessage("application.visitorPlannigBean.creer"));
    }

    public void annuler() {
    }

    /**
     * Permet de recuperer le personnel connecté et la liste de personnels
     * subordonnés s'il y en a.
     * @return une liste de personnel
     * @throws VueException 
     */
    public List<Personnel> getListPersonnelSubordonne() throws VueException {
        if (getLoginControler().getUtilisateurConnecte() != null) {
            List<Personnel> listPersonnel = new ArrayList<Personnel>();
            if (getLoginControler().isChefCours()) {
                try {
                    listPersonnel = personnelFacade.getSubordonnes(getLoginControler().getUtilisateurConnecte().getEntite(), NiveauHierarchique.COURS);
                } catch (MetierException mex) {
                    Logger.getLogger(VisitorPlanningBean.class.getCanonicalName()).log(Level.SEVERE, null, mex);
                }
            } else {
                listPersonnel.add(getLoginControler().getUtilisateurConnecte().getPersonnel());
            }
            return listPersonnel;
        }
        return new ArrayList<Personnel>();

    }

    /**
     * @return the personnel
     */
    public Personnel getPersonnel() {
        return personnel;
    }

    /**
     * @param personnel the personnel to set
     */
    public void setPersonnel(Personnel personnel) {
        this.personnel = personnel;
    }

    /**
     * active le lien d'une inscription en vérifiant si la personne 
     * est connectée et sa fonction
     * @return vrai ou faux
     */
    public boolean activerLienInscription() {
        if (getLoginControler().isUtilisateur()) {
            return true;
        }
        return false;
    }

    /**
     * @return the initialDateSchedule
     */
    public Date getInitialDateSchedule() {
        return initialDateSchedule;
    }

    /**
     * @param initialDateSchedule the initialDateSchedule to set
     */
    public void setInitialDateSchedule(Date initialDateSchedule) {
        this.initialDateSchedule = initialDateSchedule;
    }
}
